import { Component, OnInit } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';
import { HttpClient, HttpParams, HttpErrorResponse } from '@angular/common/http';
import { SharedModule } from '../../shared/shared.module';
import { PagedResultDto } from '@abp/ng.core';

interface KuCunYuJingDto {
  id: number;
  serialNumber: number;
  goodsCode: string;
  goodsName: string;
  specification: string;
  unit: string;
  goodsType: string;
  currentStock: number;
  stockLowerLimit: number;
  stockUpperLimit: number;
  belowLowerLimit: string;
  aboveUpperLimit: string;
}

interface KuCunYuJingQueryParams {
  GoodsCode?: string;
  GoodsName?: string;
  GoodsType?: string;
  Status?: string;
  SkipCount: number;
  MaxResultCount: number;
  Sorting?: string;
}

@Component({
  selector: 'app-ku-cun-yu-jing',
  standalone: true,
  imports: [
    CommonModule,
    FormsModule,
    SharedModule
  ],
  templateUrl: './ku-cun-yu-jing.component.html',
  styleUrls: ['./ku-cun-yu-jing.component.scss']
})
export class KuCunYuJingComponent implements OnInit {
  // 查询参数
  queryParams: KuCunYuJingQueryParams = {
    SkipCount: 0,
    MaxResultCount: 10
  };

  // 页码和页大小设置
  pageIndex = 1;
  pageSize = 10;
  total = 0;
  
  // 数据列表
  dataList: KuCunYuJingDto[] = [];
  allDataList: KuCunYuJingDto[] = []; // 用于存储所有数据，提取下拉选项
  
  // 选中的行
  selectedRows: number[] = [];
  
  // 加载状态
  loading = false;
  apiError = false;
  errorMessage = '';
  
  // 下拉选项 - 会从数据中提取
  goodsTypeOptions: string[] = ['全部类型'];
  statusOptions: string[] = ['全部状态', '低于下限', '高于上限', '正常'];
  
  // 统计数据
  statistics = {
    totalItems: 0,
    belowLowerItems: 0,
    aboveUpperItems: 0,
    normalItems: 0
  };

  constructor(private http: HttpClient) {}

  ngOnInit(): void {
    console.log('KuCunYuJingComponent初始化');
    // 尝试从服务器获取下拉选项
    this.fetchOptionsFromServer();
    // 加载数据
    this.loadData();
  }
  
  // 从服务器获取下拉选项
  fetchOptionsFromServer(): void {
    console.log('尝试从服务器获取下拉选项...');
    
    // 创建一个包含大量数据的请求，以获取更多数据用于提取选项
    const apiUrl = 'https://localhost:44359/api/app/ku-cun-yu-jing';
    let params = new HttpParams()
      .set('MaxResultCount', '1000') // 获取尽可能多的数据
      .set('SkipCount', '0');
    
    this.http.get<PagedResultDto<KuCunYuJingDto>>(apiUrl, { params })
      .subscribe({
        next: (response) => {
          if (response && response.items && response.items.length > 0) {
            console.log('成功获取选项数据，记录数:', response.items.length);
            // 更新全部数据列表
            this.updateAllDataList(response.items);
            // 从数据中提取下拉选项
            this.extractOptionsFromData();
          } else {
            console.warn('获取选项数据为空，将使用模拟数据');
            // 创建模拟数据并提取选项
            this.createMockOptionsData();
          }
        },
        error: (error) => {
          console.error('获取选项数据失败:', error);
          // 创建模拟数据并提取选项
          this.createMockOptionsData();
        }
      });
  }
  
  // 更新全部数据列表
  updateAllDataList(newData: KuCunYuJingDto[]): void {
    // 合并新数据到全部数据列表，避免重复
    newData.forEach(item => {
      const exists = this.allDataList.some(existingItem => existingItem.id === item.id);
      if (!exists) {
        this.allDataList.push(item);
      }
    });
  }
  
  // 从数据中提取下拉选项
  extractOptionsFromData(): void {
    // 商品类型选项（去重）
    const goodsTypeSet = new Set<string>();
    goodsTypeSet.add('全部类型'); // 始终保留"全部类型"选项
    
    this.allDataList.forEach(item => {
      if (item.goodsType && item.goodsType.trim() !== '') {
        goodsTypeSet.add(item.goodsType);
      }
    });
    
    this.goodsTypeOptions = Array.from(goodsTypeSet).sort((a, b) => {
      // 确保"全部类型"始终在第一位
      if (a === '全部类型') return -1;
      if (b === '全部类型') return 1;
      return a.localeCompare(b);
    });
    
    console.log('从数据中提取的商品类型选项:', this.goodsTypeOptions);
    
    // 如果选项为空，添加一些默认选项
    if (this.goodsTypeOptions.length <= 1) {
      this.goodsTypeOptions = ['全部类型', '饮料', '食品', '日用品', '办公设备', '其他'];
      console.warn('未能从数据中提取商品类型选项，使用默认值');
    }
  }
  
  // 创建模拟数据用于提取选项
  createMockOptionsData(): void {
    console.log('创建模拟数据用于提取下拉选项...');
    
    // 生成足够多样化的模拟数据以提供丰富的选项
    const mockItems: KuCunYuJingDto[] = [];
    
    // 模拟数据中的商品类型
    const goodsTypes = ['饮料', '食品', '日用品', '办公设备', '电子产品', '服装', '化妆品', '玩具', '文具', '工具'];
    
    // 生成30条模拟数据以确保覆盖各种情况
    for (let i = 1; i <= 30; i++) {
      const isLow = i <= 12;
      const isHigh = i > 12 && i <= 20;
      
      const mockItem: KuCunYuJingDto = {
        id: i,
        serialNumber: i,
        goodsCode: `HPDH${10000 + i}`,
        goodsName: `商品${i}`,
        specification: i % 3 === 0 ? '规格A' : (i % 3 === 1 ? '规格B' : '规格C'),
        unit: i % 2 === 0 ? '箱' : '个',
        goodsType: goodsTypes[i % goodsTypes.length],
        currentStock: isLow ? 5 + i : (isHigh ? 110 + (i - 12) * 5 : 50 + (i - 20) * 3),
        stockLowerLimit: 20,
        stockUpperLimit: 100,
        belowLowerLimit: isLow ? '是' : '否',
        aboveUpperLimit: isHigh ? '是' : '否'
      };
      
      mockItems.push(mockItem);
    }
    
    // 更新全部数据列表
    this.updateAllDataList(mockItems);
    
    // 从数据中提取下拉选项
    this.extractOptionsFromData();
  }

  // 加载数据
  loadData(): void {
    console.log('开始加载库存预警数据');
    this.loading = true;
    this.apiError = false;
    
    // 计算跳过的记录数
    this.queryParams.SkipCount = (this.pageIndex - 1) * this.pageSize;
    this.queryParams.MaxResultCount = this.pageSize;
    
    const apiUrl = 'https://localhost:44359/api/app/ku-cun-yu-jing';
    
    // 创建HttpParams对象
    let params = new HttpParams();
    
    // 添加查询参数
    if (this.queryParams.GoodsCode) {
      params = params.set('GoodsCode', this.queryParams.GoodsCode);
    }
    if (this.queryParams.GoodsName) {
      params = params.set('GoodsName', this.queryParams.GoodsName);
    }
    if (this.queryParams.GoodsType && this.queryParams.GoodsType !== '全部类型') {
      params = params.set('GoodsType', this.queryParams.GoodsType);
    }
    if (this.queryParams.Status && this.queryParams.Status !== '全部状态') {
      params = params.set('Status', this.queryParams.Status);
    }
    
    // 必须的分页参数
    params = params.set('SkipCount', this.queryParams.SkipCount.toString());
    params = params.set('MaxResultCount', this.queryParams.MaxResultCount.toString());
    
    if (this.queryParams.Sorting) {
      params = params.set('Sorting', this.queryParams.Sorting);
    }
    
    console.log('发送请求参数:', params.toString());
    console.log(`当前页码: ${this.pageIndex}, 每页条数: ${this.pageSize}`);
    
    this.http.get<PagedResultDto<KuCunYuJingDto>>(apiUrl, { params })
      .subscribe({
        next: (response) => {
          console.log('API返回数据:', response);
          if (response && response.items) {
            console.log('API返回数据条数:', response.items.length);
            this.dataList = response.items;
            this.total = response.totalCount;
            
            // 更新全部数据列表，用于提取下拉选项
            this.updateAllDataList(response.items);
            // 从数据中提取下拉选项
            this.extractOptionsFromData();
            
            this.calculateStatistics();
          } else {
            console.warn('API返回数据格式不正确:', response);
            // 使用模拟数据
            this.mockData();
          }
          this.loading = false;
        },
        error: (error: HttpErrorResponse) => {
          console.error('获取库存预警数据失败:', error);
          this.loading = false;
          this.apiError = true;
          
          if (error.status === 0) {
            this.errorMessage = '网络错误或CORS问题，请检查网络连接和后端CORS配置';
          } else {
            this.errorMessage = `获取数据失败: ${error.status} ${error.statusText}`;
            if (error.error && error.error.error) {
              this.errorMessage += ` - ${error.error.error.message || '未知错误'}`;
            }
          }
          
          // 使用模拟数据
          this.mockData();
        }
      });
  }
  
  // 模拟数据（当API返回错误时使用）
  mockData(): void {
    console.log('使用模拟数据');
    
    // 生成模拟数据
    const mockItems: KuCunYuJingDto[] = [];
    
    // 模拟数据中的商品类型
    const goodsTypes = ['饮料', '食品', '日用品', '办公设备', '电子产品', '服装', '化妆品', '玩具', '文具', '工具'];
    
    // 低于下限的商品
    for (let i = 1; i <= 5; i++) {
      mockItems.push({
        id: i,
        serialNumber: i,
        goodsCode: `HPDH${10000 + i}`,
        goodsName: `商品${i}`,
        specification: i % 2 === 0 ? '规格A' : '规格B',
        unit: '箱',
        goodsType: goodsTypes[i % goodsTypes.length],
        currentStock: 5 + i,
        stockLowerLimit: 20,
        stockUpperLimit: 100,
        belowLowerLimit: '是',
        aboveUpperLimit: '否'
      });
    }
    
    // 高于上限的商品
    for (let i = 6; i <= 8; i++) {
      mockItems.push({
        id: i,
        serialNumber: i,
        goodsCode: `HPDH${10000 + i}`,
        goodsName: `商品${i}`,
        specification: i % 2 === 0 ? '规格A' : '规格B',
        unit: '箱',
        goodsType: goodsTypes[i % goodsTypes.length],
        currentStock: 110 + (i - 5) * 5,
        stockLowerLimit: 20,
        stockUpperLimit: 100,
        belowLowerLimit: '否',
        aboveUpperLimit: '是'
      });
    }
    
    // 正常库存的商品
    for (let i = 9; i <= 10; i++) {
      mockItems.push({
        id: i,
        serialNumber: i,
        goodsCode: `HPDH${10000 + i}`,
        goodsName: `商品${i}`,
        specification: i % 2 === 0 ? '规格A' : '规格B',
        unit: '箱',
        goodsType: goodsTypes[i % goodsTypes.length],
        currentStock: 50 + (i - 8) * 10,
        stockLowerLimit: 20,
        stockUpperLimit: 100,
        belowLowerLimit: '否',
        aboveUpperLimit: '否'
      });
    }
    
    // 设置数据列表
    this.dataList = mockItems;
    
    // 设置总数
    this.total = mockItems.length;
    
    // 更新全部数据列表，用于提取下拉选项
    this.updateAllDataList(mockItems);
    
    // 从数据中提取下拉选项
    this.extractOptionsFromData();
    
    // 计算统计数据
    this.calculateStatistics();
  }
  
  // 计算统计数据
  calculateStatistics(): void {
    // 初始化统计数据
    this.statistics = {
      totalItems: this.total,
      belowLowerItems: 0,
      aboveUpperItems: 0,
      normalItems: 0
    };
    
    // 遍历数据列表，统计各种状态的数量
    this.dataList.forEach(item => {
      if (item.belowLowerLimit === '是') {
        this.statistics.belowLowerItems++;
      } else if (item.aboveUpperLimit === '是') {
        this.statistics.aboveUpperItems++;
      } else {
        this.statistics.normalItems++;
      }
    });
  }
  
  // 重置搜索条件
  reset(): void {
    // 保存当前页大小
    const currentPageSize = this.pageSize;
    
    // 完全重置查询参数
    this.queryParams = {
      SkipCount: 0,
      MaxResultCount: currentPageSize
    };
    
    // 重置页码
    this.pageIndex = 1;
    
    // 重新加载数据
    this.loadData();
  }
  
  // 搜索
  search(): void {
    this.pageIndex = 1;
    this.loadData();
  }
  
  // 计算总页数
  get totalPages(): number {
    return Math.ceil(this.total / this.pageSize);
  }

  // 获取分页显示的页码范围
  getPageRange(): number[] {
    const totalPages = this.totalPages;
    const currentPage = this.pageIndex;
    
    // 最多显示5个页码
    const maxPageButtons = 5;
    
    let startPage = Math.max(1, currentPage - Math.floor(maxPageButtons / 2));
    let endPage = startPage + maxPageButtons - 1;
    
    if (endPage > totalPages) {
      endPage = totalPages;
      startPage = Math.max(1, endPage - maxPageButtons + 1);
    }
    
    const pages = [];
    for (let i = startPage; i <= endPage; i++) {
      pages.push(i);
    }
    
    return pages;
  }

  // 页码变更
  pageIndexChange(index: number): void {
    if (index < 1 || index > this.totalPages || index === this.pageIndex) {
      return;
    }
    this.pageIndex = index;
    this.loadData();
  }
  
  // 页大小变更
  pageSizeChange(size: number): void {
    this.pageSize = Number(size);
    this.pageIndex = 1; // 重置到第一页
    this.loadData();
  }
  
  // 选择行
  toggleSelection(id: number): void {
    const index = this.selectedRows.indexOf(id);
    if (index === -1) {
      this.selectedRows.push(id);
    } else {
      this.selectedRows.splice(index, 1);
    }
  }
  
  // 导出
  exportData(): void {
    console.log('导出数据');
    alert('导出功能正在开发中');
  }
  
  // 刷新
  refresh(): void {
    this.loadData();
  }

  // 获取库存状态
  getStatus(item: KuCunYuJingDto): string {
    if (item.belowLowerLimit === '是') {
      return '低于下限';
    } else if (item.aboveUpperLimit === '是') {
      return '高于上限';
    } else {
      return '正常';
    }
  }

  // 获取库存状态对应的样式类
  getStatusClass(item: KuCunYuJingDto): string {
    if (item.belowLowerLimit === '是') {
      return 'text-danger';
    } else if (item.aboveUpperLimit === '是') {
      return 'text-warning';
    } else {
      return 'text-success';
    }
  }

  // 计算下限比率
  calculateLowerRate(item: KuCunYuJingDto): string {
    if (item.stockLowerLimit > 0) {
      // 计算当前库存占下限的百分比
      const percentage = (item.currentStock / item.stockLowerLimit) * 100;
      return percentage.toFixed(0) + '%';
    }
    return '-';
  }

  // 计算上限比率
  calculateUpperRate(item: KuCunYuJingDto): string {
    if (item.stockUpperLimit > 0) {
      // 计算当前库存占上限的百分比
      const percentage = (item.currentStock / item.stockUpperLimit) * 100;
      return percentage.toFixed(0) + '%';
    }
    return '-';
  }
  
  // 获取下限比率进度条宽度
  getLowerRateWidth(item: KuCunYuJingDto): string {
    if (item.stockLowerLimit > 0) {
      const percentage = Math.min((item.currentStock / item.stockLowerLimit) * 100, 100);
      return percentage + '%';
    }
    return '0%';
  }

  // 获取上限比率进度条宽度
  getUpperRateWidth(item: KuCunYuJingDto): string {
    if (item.stockUpperLimit > 0) {
      const percentage = Math.min((item.currentStock / item.stockUpperLimit) * 100, 100);
      return percentage + '%';
    }
    return '0%';
  }

  // 获取下限比率进度条颜色类
  getLowerRateColorClass(item: KuCunYuJingDto): string {
    if (item.belowLowerLimit === '是') {
      return 'bg-danger';
    } else if (item.currentStock && item.stockLowerLimit && 
              (item.currentStock / item.stockLowerLimit) < 1.2) {
      // 接近下限但未达到预警
      return 'bg-warning';
    } else {
      return 'bg-success';
    }
  }

  // 获取上限比率进度条颜色类
  getUpperRateColorClass(item: KuCunYuJingDto): string {
    if (item.aboveUpperLimit === '是') {
      return 'bg-warning';
    } else if (item.currentStock && item.stockUpperLimit && 
              (item.currentStock / item.stockUpperLimit) > 0.8) {
      // 接近上限但未达到预警
      return 'bg-info';
    } else {
      return 'bg-success';
    }
  }

  // 获取下限比率文本颜色类
  getLowerRateTextClass(item: KuCunYuJingDto): string {
    if (item.belowLowerLimit === '是') {
      return 'text-danger';
    } else if (item.currentStock && item.stockLowerLimit && 
              (item.currentStock / item.stockLowerLimit) < 1.2) {
      return 'text-warning';
    } else {
      return 'text-success';
    }
  }

  // 获取上限比率文本颜色类
  getUpperRateTextClass(item: KuCunYuJingDto): string {
    if (item.aboveUpperLimit === '是') {
      return 'text-warning';
    } else if (item.currentStock && item.stockUpperLimit && 
              (item.currentStock / item.stockUpperLimit) > 0.8) {
      return 'text-info';
    } else {
      return 'text-success';
    }
  }
}
